Trivy y Grype: escaneo de imágenes de contenedor en el CI

javi
Escudo digital representando escaneo de seguridad

Escanear imágenes de contenedor antes del despliegue ha pasado de ser “buena práctica” a ser requisito en pipelines modernos. Dos herramientas open-source dominan este espacio: Trivy de Aqua Security y Grype de Anchore. Ambas hacen bien el trabajo básico, con diferencias sutiles que importan según tu contexto.

Qué hace cada una

Las dos escanean imágenes (y más) contra bases de datos de vulnerabilidades conocidas (CVE). Detectan:

  • Paquetes de sistema operativo vulnerables (apt, rpm, apk).
  • Dependencias de lenguaje con CVE (npm, pip, gem, go.mod, Cargo).
  • Ficheros de configuración problemáticos (Dockerfiles con patrones inseguros, Kubernetes manifests expuestos).
  • SBOMs en varios formatos.

La salida es una lista de vulnerabilidades con severidad, paquete afectado, y CVE ID.

Diferencias de arquitectura

Trivy

  • Base de datos interna: Trivy DB, sincroniza desde múltiples fuentes (NVD, vendor advisories, GitHub Security Advisories).
  • Formato de base comprimido (~50 MB), diseñado para escaneos offline.
  • Soporta escaneo de imágenes, filesystems locales, repositorios git, IaC (Terraform, CloudFormation, Kubernetes).
  • Modo cliente-servidor para escaneos distribuidos.

Grype

  • Base de datos: Vulnerability Database, compilada desde fuentes similares.
  • Usa Syft para generación de SBOM (mismo equipo), lo que hace el pipeline SBOM→escaneo nativo.
  • Más modular: Syft genera, Grype escanea, herramientas adicionales consumen el SBOM.
  • Soporta attestations de SBOM vía cosign.

Cobertura comparada

En tests realizados sobre imágenes diversas (alpine, debian, node, python, ruby):

  • Ambas detectan la gran mayoría de CVE conocidas en paquetes de SO.
  • Trivy suele detectar más en ecosistemas de lenguaje por integración más directa con lockfiles.
  • Grype destaca en imágenes con SBOM precomputado por Syft — elimina reindexación.
  • Ambas pueden dar falsos positivos por versiones backporteadas (el parche está aplicado pero el número de versión sigue siendo el “vulnerable” para el CVE base).

En la práctica, la diferencia de cobertura es <5% en escenarios típicos. Más relevante: la velocidad de actualización de bases de datos y la calidad de interpretación de severidad.

Rendimiento

Benchmarks en una imagen Python 3.11 de ~200 MB:

  • Trivy: 3-5 segundos (primera ejecución con caché de DB), <1s subsiguientes.
  • Grype: 4-6 segundos primera, ~2s subsiguientes.

En CI con imágenes grandes (>1 GB, multi-stack), la velocidad importa. Para CI de 50-100 builds/día, cualquiera es suficiente. Para pipelines con cientos de builds/hora, Trivy suele ser algo más rápido.

Integración en CI

Ambas tienen integraciones bien documentadas:

Trivy en GitHub Actions

- name: Run Trivy
  uses: aquasecurity/trivy-action@master
  with:
    image-ref: 'my-app:${{ github.sha }}'
    format: 'sarif'
    output: 'trivy-results.sarif'
    severity: 'CRITICAL,HIGH'
    exit-code: '1'

El flag exit-code: '1' falla el build si hay CRITICAL o HIGH. Integración con GitHub Security tab vía SARIF.

Grype en GitLab CI

scan_image:
  stage: test
  script:
    - grype my-app:$CI_COMMIT_SHA -o sarif > grype.sarif
    - grype my-app:$CI_COMMIT_SHA --fail-on high

Ambas pueden integrarse con SonarQube, DefectDojo y otros agregadores de resultados.

Configuración de falsos positivos

El problema operacional más común con cualquier scanner: demasiados falsos positivos generan fatiga. Dos enfoques:

  • .trivyignore (Trivy) o similar en Grype: listar explícitamente CVEs que sabes no aplican (parche aplicado, funcionalidad no usada, etc.).
  • VEX (Vulnerability Exploitability eXchange): formato emergente para declarar qué vulnerabilidades son explotables en tu contexto específico. Ambas herramientas están añadiendo soporte.

Mantener esta lista requiere disciplina — revisión trimestral para no acumular supresiones obsoletas que oculten problemas reales.

Más allá del escaneo básico

Ambas herramientas van más allá de CVE:

  • Políticas y compliance: ejecutar reglas que fallen builds si se usan imágenes base no permitidas, si las imágenes son demasiado grandes, etc.
  • Licencias: detectar dependencias con licencias incompatibles (GPL en producto comercial cerrado).
  • Secrets: detectar API keys o credenciales expuestas en layers de imagen (Trivy tiene --scanners secret).

Ver también nuestra cobertura de ataques a la cadena de suministro y cómo defenderse — escaneo es una capa, no la única.

Conclusión

Trivy y Grype son alternativas prácticamente equivalentes para escaneo de imágenes en 2023. La diferencia suele estar en ecosistema más amplio: si ya usas Anchore/Syft, Grype encaja; si quieres una herramienta todo-en-uno con mejor integración IaC, Trivy. Lo importante es tener alguna — ambas son mejores que ninguna.

Síguenos en jacar.es para más sobre DevSecOps, seguridad de contenedores y pipelines CI modernos.

Entradas relacionadas